package actividades;

import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

import org.osmdroid.DefaultResourceProxyImpl;
import org.osmdroid.util.GeoPoint;
import org.osmdroid.views.MapController;
import org.osmdroid.views.MapView;
import org.osmdroid.views.overlay.SimpleLocationOverlay;

import tratamientoDatos.PintarLineaMapa;
import tratamientoDatos.Ruta;
import tratamientoDatos.SimpleXYSeries;
import tratamientoDatos.TipoRuta;
import tratamientoDatos.UsuarioSingleton;
import world.trainer.R;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.graphics.Color;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.SystemClock;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.Chronometer;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import com.androidplot.ui.AnchorPosition;
import com.androidplot.ui.widget.Widget;
import com.androidplot.xy.LineAndPointFormatter;
import com.androidplot.xy.LineAndPointRenderer;
import com.androidplot.xy.XLayoutStyle;
import com.androidplot.xy.XYPlot;
import com.androidplot.xy.YLayoutStyle;
import comunicacionServidor.FuncionesJSON;

public class MainActivity extends Activity {

	// Cronometro
	private Chronometer crono;
	private String estado = "inactivo";
	private long memoTiempo;

	// Mapa
	private DefaultResourceProxyImpl mResourceProxy;
	private MapView myOpenMapView;
	private MapController myMapController;
	private PintarLineaMapa lineam, lineam2;

	// Posiciones
	private SimpleLocationOverlay posicionActualSobreElMapa;
	private LocationManager manejadorPosicion;
	private LocationListener locListener;
	private GeoPoint posicionActual, posicionAnterior, posicionPausada;

	// Recorrido
	private Ruta ruta, rutaCargada;
	private boolean cargada;

	// Datos ruta
	private long instanteActual, instanteAnterior, instanteInicial;
	private double distanciaTotal, distancia, velocidadMaxima,
			velocidadMaximaCiclismo, velocidadMaximaCarrera, velocidadMedia,
			velocidad, calorias, peso, duracion, distanciaTotalCargada;
	private int deporteSeleccionado, tipo;
	private String nombreRutaCargada;

	// TextView & Buttons & Spinner
	private TextView velocidadText, velocidadMediaText, velocidadMaximaText,
			caloriasText, distanciaText;
	private ImageButton btnStart, btnStop;
	private ImageView btnPosicionar;
	private Spinner spinner;

	private int posicionar = 1;// 0 no posicionar, 1 si.
	private ProgressDialog dialog;

	// Tablas coeficientes calorias
	private final double[] tablaCoeficientesCiclismo = { 0, 0.0005, 0.001,
			0.005, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1,
			0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21,
			0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32,
			0.33, 0.34, 0.35 };
	private final double[] tablaCoeficientesCarrera = { 0, 0.001, 0.005, 0.01,
			0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.098, 0.106,
			0.114, 0.122, 0.13, 0.138, 0.146, 0.154, 0.162, 0.17, 0.178, 0.186,
			0.194, 0.202 };

	private Bundle bundle;
	private boolean correcto;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main_activity);
		correcto = true;

		// Inicializacion variables
		distanciaText = (TextView) findViewById(R.id.txtDistancia);
		velocidadText = (TextView) findViewById(R.id.txtVelocidad);
		velocidadMediaText = (TextView) findViewById(R.id.txtVelocidadMedia);
		velocidadMaximaText = (TextView) findViewById(R.id.txtVelocidadMaxima);
		caloriasText = (TextView) findViewById(R.id.txtCalorias);
		crono = (Chronometer) findViewById(R.id.cronometro);
		myOpenMapView = (MapView) findViewById(R.id.openmapview);
		btnStart = (ImageButton) findViewById(R.id.botonComenzar);
		btnStop = (ImageButton) findViewById(R.id.botonParar);
		spinner = (Spinner) findViewById(R.id.selecctor);
		btnPosicionar = (ImageView) findViewById(R.id.botonPosicionar);
		btnPosicionar.setVisibility(View.INVISIBLE);
		dialog = ProgressDialog.show(this, "", "Guardando...", true);
		dialog.dismiss();
		deporteSeleccionado = 0;
		ruta = new Ruta();

		// Se colocan los diferentes deportes a elegir en el spinner
		ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
				this, R.array.deportes, android.R.layout.simple_spinner_item);
		adapter.setDropDownViewResource(android.R.layout.simple_dropdown_item_1line);
		spinner.setAdapter(adapter);

		spinner.setOnItemSelectedListener(new OnItemSelectedListener() {

			public void onItemSelected(AdapterView<?> parentView,
					View selectedView, int posicion, long id) {
				deporteSeleccionado = posicion;
			}

			public void onNothingSelected(AdapterView<?> parentView) {
				deporteSeleccionado = 0;
			}
		});

		mResourceProxy = new DefaultResourceProxyImpl(getApplicationContext());

		instanteAnterior = (long) (SystemClock.elapsedRealtime() * 0.001);
		cargada = false;

		// Posicion inicial
		myOpenMapView.setBuiltInZoomControls(false);
		myMapController = myOpenMapView.getController();
		myMapController.setZoom(20);
		myMapController.setCenter(new GeoPoint(0, 0));
		myOpenMapView.setMultiTouchControls(true);

		posicionActualSobreElMapa = new SimpleLocationOverlay(this,
				mResourceProxy);
		myOpenMapView.getOverlays().add(posicionActualSobreElMapa);

		// En el bloque condicional se carga la ruta elegida en la vista de
		// cargar
		// Si se ha cargado ninguna ruta, no se entra en el bloque y continua
		// la ejecucion normal
		bundle = getIntent().getExtras();

		if (bundle.get("ACTIVITY").equals("CargarActivity")) {

			cargada = true;
			posicionar = 0;
			btnPosicionar
					.setImageResource(R.drawable.posicion_negro_tachado_40);
			distanciaTotalCargada = (float) bundle.getDouble("DISTANCIA");
			velocidadMedia = (float) bundle.getDouble("VELOCIDADMEDIA");
			velocidadMaxima = (float) bundle.getDouble("VELOCIDADMAXIMA");
			duracion = (float) bundle.getDouble("DURACION");
			calorias = (float) bundle.getDouble("CALORIAS");
			tipo = bundle.getInt("TIPO");
			rutaCargada = bundle.getParcelable("RUTA");
			nombreRutaCargada = bundle.getString("NOMBRERUTACARGADA");

			GeoPoint p1 = null, p2 = null, pinicial = null;
			boolean primera = true;

			for (Entry<Long, GeoPoint> punto : rutaCargada.getCamino()
					.entrySet()) {
				if (primera == true) {
					p1 = punto.getValue();
					pinicial = p1;
					primera = false;
				} else {
					p2 = punto.getValue();

					PintarLineaMapa linea = new PintarLineaMapa(
							getApplicationContext());
					linea.parametrosOverlay(p1, p2, TipoRuta.RUTACARGADA);
					myOpenMapView.getOverlays().add(linea);
					p1 = p2;
				}
			}

			myMapController.setZoom(21);// entre 1 y 21
			myMapController.animateTo(pinicial);
			myMapController.setCenter(pinicial);
			myOpenMapView.postInvalidate();

			if (tipo == 0) {
				String[] cadena = String.format("%.1f", velocidadMaxima).split(
						",");
				int decimal = Integer.parseInt(cadena[1]);
				decimal = 6 * decimal;
				String velocMax = cadena[0] + "," + String.valueOf(decimal);
				velocidadMaximaText.setText(velocMax + " min/km");

				cadena = String.format("%.1f", velocidadMedia).split(",");
				decimal = Integer.parseInt(cadena[1]);
				decimal = 6 * decimal;
				String velocMedia = cadena[0] + "," + String.valueOf(decimal);
				velocidadMediaText.setText(velocMedia + " min/km");
			} else {
				velocidadMaximaText.setText(String.format("%.1f",
						velocidadMaxima) + " km/h");
				velocidadMediaText.setText(String
						.format("%.1f", velocidadMedia) + " km/h");
			}
			distanciaText.setText(String.format("%.2f", distanciaTotalCargada)
					+ " km");
			caloriasText.setText(String.format("%.0f", calorias) + " cal");
			velocidadText.setText("-");
			crono.setBase((long) (SystemClock.elapsedRealtime() - duracion));

		}

		// Se obtiene el valor del peso del usuario para utilizarlo en el
		// calculo
		// de las calorias

		UsuarioSingleton usuario = UsuarioSingleton.getInstance();
		peso = usuario.getPeso();

		// Se activa el GPS y se comienzan a recibir posiciones
		activarGPS();

		// Tramiento de los eventos de bntStart
		btnStart.setOnClickListener(new OnClickListener() {
			public void onClick(View arg0) {
				if (estado == "inactivo") {
					ruta = new Ruta();
					distanciaTotal = 0;
					velocidadMaximaCiclismo = 0;
					velocidadMaximaCarrera = Double.MAX_VALUE;
					instanteInicial = SystemClock.elapsedRealtime();
					crono.setBase(instanteInicial);
					crono.start();
					estado = "activo";
					btnStart.setImageResource(R.drawable.pause);
					return;
				}
				if (estado == "activo") {
					memoTiempo = SystemClock.elapsedRealtime();
					crono.stop();
					estado = "pausado";
					btnStart.setImageResource(R.drawable.play);
					return;
				} else {
					crono.setBase(crono.getBase()
							+ SystemClock.elapsedRealtime() - memoTiempo);
					crono.start();
					estado = "activo";
					btnStart.setImageResource(R.drawable.pause);
				}

			}
		});

		// Tratamiento de los eventos de btnStop
		btnStop.setOnClickListener(new OnClickListener() {
			public void onClick(View arg0) {
				crono.stop();
				btnStart.setImageResource(R.drawable.play);
				myOpenMapView.getOverlayManager().clear();
				myOpenMapView.getOverlays().add(posicionActualSobreElMapa);
				estado = "inactivo";
				pintarPerfil();
			}
		});
		btnPosicionar.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				if (posicionar == 1) {
					posicionar = 0;
					btnPosicionar
							.setImageResource(R.drawable.posicion_negro_tachado_40);
				} else {
					posicionar = 1;
					btnPosicionar
							.setImageResource(R.drawable.posicion_negro_40);
				}
			}
		});

	}

	private void activarGPS() {

		// Se crea el listener de posiciones y tratamos los diferentes eventos
		locListener = new LocationListener() {

			// Cuando cambia el estado del GPS
			public void onStatusChanged(String provider, int status,
					Bundle extras) {
			}

			// Cuando se activa el GPS
			public void onProviderEnabled(String provider) {
				// Mostramos un aviso de GPS activado
				Toast toast = Toast.makeText(getApplicationContext(),
						"GPS ACTIVADO", Toast.LENGTH_SHORT);
				toast.show();
			}

			// Cuando se desactiva el GPS
			public void onProviderDisabled(String provider) {
				// Se muestra un aviso de GPS desactivados
				Toast toast = Toast
						.makeText(
								getApplicationContext(),
								"GPS DESACTIVADO: por favor conectelo para el correcto funcionamiento",
								Toast.LENGTH_LONG);
				View textView = toast.getView();
				LinearLayout lay = new LinearLayout(getApplicationContext());
				lay.setOrientation(LinearLayout.HORIZONTAL);
				ImageView view = new ImageView(getApplicationContext());
				view.setImageResource(android.R.drawable.ic_menu_info_details);
				lay.addView(view);
				lay.addView(textView);
				toast.setView(lay);
				toast.show();
			}

			// Cuando se recibe una nueva posicion
			public void onLocationChanged(Location location) {
				// Si la posicion es valida la tratamos
				if (location != null) {
					tratarPosicion(location);
				}
			}
		};

		// Se configura el manejador de posicion con los parametros deseados
		manejadorPosicion = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
		manejadorPosicion.requestLocationUpdates(LocationManager.GPS_PROVIDER,
				0, 0, locListener);
	}

	protected void tratarPosicion(Location location) {

		// Se obtiene la ultima posicion recibida y se centra el mapa en ella
		posicionActual = new GeoPoint(location);
		if (posicionar == 1) {
			posicionActualSobreElMapa.setLocation(posicionActual);
			myMapController.animateTo(posicionActual);
			myMapController.setCenter(posicionActual);
		}

		// Si se ha comenzado el recorrido
		if (ruta != null) {

			// Se actualiza el instante actual
			instanteActual = SystemClock.elapsedRealtime() - instanteInicial;

			// Si no se ha introducido ninguna ruta o esta pausado se actualiza
			// posicionPausada y posicionAnterior para que no se tengan en
			// cuenta para los datos de la ruta
			if (ruta.getCamino().size() == 0 || estado.equals("pausado")) {
				posicionPausada = posicionAnterior;
				posicionAnterior = posicionActual;
			}

			// Si se ha comenzado una ruta
			if (!estado.equals("inactivo")) {

				// y se ha introducido al menos una posicion
				if (ruta.getCamino().size() > 0) {

					// En modo pausado
					if (estado.equals("pausado")) {

						// Se pinta el camino recorrido en modo pausa
						lineam2 = new PintarLineaMapa(getApplicationContext());
						lineam2.parametrosOverlay(posicionPausada,
								posicionActual, TipoRuta.RUTAPAUSADA);
						myOpenMapView.getOverlays().add(lineam2);
						myOpenMapView.postInvalidate();

						// En modo activo
					} else {

						// Se pinta el camino recorrido
						lineam = new PintarLineaMapa(getApplicationContext());
						lineam.parametrosOverlay(posicionAnterior,
								posicionActual, TipoRuta.RUTAGENERADA);
						myOpenMapView.getOverlays().add(lineam);
						myOpenMapView.postInvalidate();

						// Se calculan los datos
						distancia = posicionAnterior.distanceTo(posicionActual);
						distancia = distancia * 0.001; // Distancia en km
						distanciaTotal = distanciaTotal + distancia;

						calorias = calculaCalorias(instanteActual,
								velocidadMedia);
						velocidad = calculaVelocidad(distancia, instanteActual
								- instanteAnterior);
						velocidadMedia = calculaVelocidad(distanciaTotal,
								instanteActual);

						// Dependiendo del deporte seleccionado se introducen
						// las velocidades con unas unidades y otras
						if (deporteSeleccionado == 0) {

							if (velocidad < velocidadMaximaCarrera && velocidad > 1) {
								velocidadMaximaCarrera = velocidad;
								String[] cadena = String.format("%.1f",
										velocidadMaximaCarrera).split(",");
								int decimal = Integer.parseInt(cadena[1]);
								decimal = 6 * decimal;
								String velocMax = cadena[0] + ","
										+ String.valueOf(decimal);
								velocidadMaximaText.setText(velocMax
										+ " min/km");

							}
							String[] cadena = String.format("%.1f",
									velocidadMedia).split(",");
							int decimal = Integer.parseInt(cadena[1]);
							decimal = 6 * decimal;
							String velocMedia = cadena[0] + ","
									+ String.valueOf(decimal);
							velocidadMediaText.setText(velocMedia + " min/km");
							velocidadText.setText(String.format("%.1f",
									velocidad) + " min/km");

						} else {
							if (velocidad > velocidadMaximaCiclismo) {
								velocidadMaximaCiclismo = velocidad;
								velocidadMaximaText.setText(String.format(
										"%.1f", velocidadMaximaCiclismo) + " km/h");
							}
							velocidadMediaText.setText(String.format("%.1f",
									velocidadMedia) + " km/h");
							velocidadText.setText(String.format("%.1f",
									velocidad) + " km/h");
						}
						caloriasText.setText(String.format("%.0f", calorias)
								+ " cal");
						distanciaText.setText(String.format("%.2f",
								distanciaTotal) + " km");

						// Se actualiza el instanteAnterior para la proxima
						// posicion
						instanteAnterior = instanteActual;
					}
				}
				// Se anyade la posicionActual e instanteActual a la ruta y se
				// actualiza posicionAnterior
				ruta.anyadirPuntoARuta(posicionActual, instanteActual);
				posicionAnterior = posicionActual;
			}
		}
	}

	private double calculaVelocidad(double distancia, double tiempo) {

		double velocidad;

		if (deporteSeleccionado == 0) {
			// Se pasa el tiempo de milisegundos a minutos
			double tiempoMin = tiempo * 0.0000167;
			if (distancia - 0.001 < 0)
				velocidad = 0;
			else
				// Se calcula la velocidad en min/km para carrera
				velocidad = tiempoMin / distancia;
		} else {
			// Se pasa el tiempo de milisegundos a horas
			double tiempoHoras = tiempo * 0.000000278;

			// Se calcula la velocidad en km/h para ciclismo
			velocidad = distancia / tiempoHoras;
		}

		return velocidad;
	}

	private double calculaCalorias(double tiempo, double velocidadMedia) {

		double calorias;
		int indice;
		// Se calcula el indice para la tabla de coeficientes y el tiempo en
		// minutos

		int tiempoMin = (int) (tiempo * 0.0006);

		if (deporteSeleccionado == 0) {

			indice = (int) Math.round(velocidadMedia);
			// Se trasnforma de min/km a km/h
			velocidadMedia = 60 / velocidadMedia;

			if (indice > tablaCoeficientesCarrera.length - 1)
				indice = tablaCoeficientesCarrera.length - 1;
			else if (indice < 0)
				indice = 0;

			// Se realiza el calculo de las calorias para carrera
			calorias = (tablaCoeficientesCarrera[indice] * 2.2 * peso * tiempoMin);
		} else {
			indice = (int) Math.round(velocidadMedia * 0.5);
			if (indice > tablaCoeficientesCiclismo.length - 1)
				indice = tablaCoeficientesCiclismo.length - 1;
			else if (indice < 0)
				indice = 0;

			// Se realiza el calculo de las calorias para ciclismo
			calorias = (tablaCoeficientesCiclismo[indice] * 2.2 * peso * tiempoMin);
		}

		return calorias;
	}

	@SuppressWarnings("deprecation")
	protected void pintarPerfil() {

		// Se crea la lista donde guardaremos las alturas de todos los puntos
		// recorridos
		List<Number> alturas = new ArrayList<Number>();

		// Se introduce en la lista las alturas correspondiente de la
		// rutaCargada o la realizada
		if (cargada) {
			for (GeoPoint g : rutaCargada.getCamino().values()) {
				alturas.add(g.getAltitude());
			}
		} else {
			for (GeoPoint g : ruta.getCamino().values()) {
				alturas.add(g.getAltitude());
			}
		}

		// Inicializamos el objeto XYPlot
		XYPlot mySimpleXYPlot = (XYPlot) findViewById(R.id.perfil);

		// Se anyaden las alturas a la grafica y se le da estilo
		mySimpleXYPlot.addSeries(
				new SimpleXYSeries(alturas),
				LineAndPointRenderer.class,
				new LineAndPointFormatter(Color.rgb(0, 200, 0), Color.rgb(0,
						100, 0), Color.rgb(150, 190, 150)));

		// Se reduce el numero de etiquetas del rango
		mySimpleXYPlot.getGraphWidget().setRangeTicksPerLabel(4);

		// Se posiciona la grafica
		Widget domainLabelWidget = mySimpleXYPlot.getDomainLabelWidget();
		mySimpleXYPlot.position(domainLabelWidget, 45,
				XLayoutStyle.ABSOLUTE_FROM_LEFT, 0,
				YLayoutStyle.ABSOLUTE_FROM_BOTTOM, AnchorPosition.LEFT_BOTTOM);

		// Se etiquetan el dominio y el rango
		mySimpleXYPlot.setDomainLabel("Distancia (km)");
		mySimpleXYPlot.setRangeLabel("Altitud (m)");

		// Se quitan las ayudas visuales para el posicionamiento
		mySimpleXYPlot.disableAllMarkup();

	}

	protected void onDestroy() {

		// Se detienen las actualizaciones de posiciones
		if (locListener != null)
			manejadorPosicion.removeUpdates(locListener);
		finish();
		super.onDestroy();
	}

	public void onBackPressed() {

		// Se detienen las actualizaciones de posiciones
		if (locListener != null)
			manejadorPosicion.removeUpdates(locListener);

		finish();
		super.onBackPressed();
	}

	public void onPause() {

		super.onPause();
	}

	public boolean onCreateOptionsMenu(Menu menu) {

		// Se crea el menu
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.main_menu, menu);
		return true;
	}

	public boolean onOptionsItemSelected(MenuItem item) {

		// Se inicializan los widgets necesarios
		final ImageButton stop = (ImageButton) findViewById(R.id.botonParar);
		final ImageButton start = (ImageButton) findViewById(R.id.botonComenzar);
		final RelativeLayout contenedorDatos = (RelativeLayout) findViewById(R.id.contenedorDatos);
		final com.androidplot.xy.XYPlot perfil = (com.androidplot.xy.XYPlot) findViewById(R.id.perfil);
		final org.osmdroid.views.MapView mapa = (org.osmdroid.views.MapView) findViewById(R.id.openmapview);
		final Chronometer crono = (Chronometer) findViewById(R.id.cronometro);

		// Segun la opcion selecciona se actua de la forma correspondiente
		switch (item.getItemId()) {

		// Se va a la configuracion de los datos del usuario
		case R.id.configuracion:

			// Se detienen las actualizaciones de posiciones
			if (locListener != null)
				manejadorPosicion.removeUpdates(locListener);
			finish();
			Intent intentConfiguracion = new Intent(this,
					ConfiguracionActivity.class);
			intentConfiguracion.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
			startActivity(intentConfiguracion);
			return true;

			// Se va al guardado de la ruta y la creacion del xml
		case R.id.guardar:

			// Si se a realizado alguna ruta
			if (ruta.getCamino().size() > 1) {

				// Se detiene el tiempo si no se le a dado ya al btnStop
				crono.stop();
				estado = "inactivo";
				btnStart.setImageResource(R.drawable.play);
				if (deporteSeleccionado == 0)
					velocidadMaxima = velocidadMaximaCarrera;
				else
					velocidadMaxima = velocidadMaximaCiclismo;

				// Se guardan en un bundle los datos a transferir al otro
				// activity
				Intent intentGuardar = new Intent(this, GuardarActivity.class);

				Bundle bundle2 = new Bundle();
				bundle2.putDouble("VELOCIDADMEDIA", velocidadMedia);
				bundle2.putDouble("VELOCIDADMAXIMA", velocidadMaxima);
				bundle2.putDouble("DURACION", instanteActual);
				bundle2.putDouble("CALORIAS", calorias);
				bundle2.putInt("TIPO", deporteSeleccionado);

				if (bundle.get("ACTIVITY").equals("CargarActivity")) {

					if (distanciaTotalCargada < distanciaTotal + 1
							&& distanciaTotalCargada > distanciaTotal - 1) {
						dialog.show();
						correcto=true;
						new ClaseComunicacion().execute();

					} else {

						bundle2.putDouble("DISTANCIA", distanciaTotal);
						bundle2.putParcelable("RUTA", ruta);
						bundle2.putString("SOLONUEVAINFORUTA", "FALSE");
						intentGuardar.putExtras(bundle2);
						intentGuardar.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
						startActivity(intentGuardar);
					}

				} else {

					bundle2.putDouble("DISTANCIA", distanciaTotal);
					bundle2.putParcelable("RUTA", ruta);
					bundle2.putString("SOLONUEVAINFORUTA", "FALSE");
					intentGuardar.putExtras(bundle2);
					intentGuardar.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
					startActivity(intentGuardar);

				}

			} else {

				// Si no se a realizado ninguna ruta se notifica al usuario
				Toast toast = Toast.makeText(getApplicationContext(),
						"Imposible guardar. Ruta no iniciada",
						Toast.LENGTH_SHORT);
				toast.show();
			}
			return true;

			// Se va al cargado de una ruta ya salvada
		case R.id.cargar:

			Intent intentCargar = new Intent(this, CargarActivity.class);
			intentCargar.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
			startActivity(intentCargar);
			return true;

			// Se cambia entre las diferentes vistas posibles: informacion, mapa
			// y perfil.
			// La vista del perfil solo es visible si se a concluido la ruta con
			// el btnStop
		case R.id.menuCambiarVista:

			crono.setVisibility(View.VISIBLE);

			if (mapa.getVisibility() == View.VISIBLE) {
				mapa.setVisibility(View.INVISIBLE);
				contenedorDatos.setVisibility(View.VISIBLE);
				btnPosicionar.setVisibility(View.INVISIBLE);
			} else if (contenedorDatos.getVisibility() == View.VISIBLE
					&& estado.equals("inactivo") && ruta.getCamino().size() > 1) {
				contenedorDatos.setVisibility(View.INVISIBLE);
				start.setVisibility(View.INVISIBLE);
				stop.setVisibility(View.INVISIBLE);
				perfil.setVisibility(View.VISIBLE);
				btnPosicionar.setVisibility(View.INVISIBLE);
			} else {
				contenedorDatos.setVisibility(View.INVISIBLE);
				perfil.setVisibility(View.INVISIBLE);
				start.setVisibility(View.VISIBLE);
				stop.setVisibility(View.VISIBLE);
				mapa.setVisibility(View.VISIBLE);
				btnPosicionar.setVisibility(View.VISIBLE);
			}
			return true;
		case R.id.salir:
			if (locListener != null)
				manejadorPosicion.removeUpdates(locListener);
			Intent intent = new Intent(this, MainActivity.class);
			intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
			finish();

			return true;
		case R.id.buscar:
			Intent intentBuscar = new Intent(this, BuscarRutaActivity.class);
			intentBuscar.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
			startActivity(intentBuscar);
			return true;

		default:
			return super.onOptionsItemSelected(item);
		}
	}

	private class ClaseComunicacion extends AsyncTask<Void, Void, Void> {

		@Override
		protected Void doInBackground(Void... params) {
			try {
				FuncionesJSON userFunction = new FuncionesJSON();
				userFunction.guardarSoloInfo(instanteActual,
						distanciaTotalCargada, velocidadMedia, velocidadMaxima,
						calorias, tipo, nombreRutaCargada);
			} catch (Exception e) {
				correcto = false;
			}
			return null;
		}

		@Override
		protected void onPostExecute(Void result) {
			dialog.dismiss();
			if (correcto) {
				Toast toast = Toast.makeText(getApplicationContext(),
						"Informacion de ruta guardada", Toast.LENGTH_SHORT);
				toast.show();
			} else {
				Toast toast = Toast.makeText(getApplicationContext(),
						"No se ha podido guardar la ruta", Toast.LENGTH_SHORT);
				toast.show();
			}
		}
	}
}
